package com.system.healthproject.model.admin.service.impl;


import com.system.healthproject.bean.IllDiscussBean;
import com.system.healthproject.bean.selectIllDiscussBean;

import com.system.healthproject.bean.selectIllDiscussByDoctorIdBean;
import com.system.healthproject.bean.updateIllDiscussInfo;
import com.system.healthproject.mapper.DiscussSingupMapper;
import com.system.healthproject.mapper.IlldiscussMapper;
import com.system.healthproject.mapper.illdiscussDoctorMapper;
import com.system.healthproject.model.admin.paramsbean.DiscussSingupParams;
import com.system.healthproject.model.admin.paramsbean.IllDiscussInfo;
import com.system.healthproject.model.admin.paramsbean.IllDiscussParams;
import com.system.healthproject.model.admin.service.IlldiscussService;
import com.system.healthproject.pojo.DiscussSingup;
import com.system.healthproject.pojo.Doctor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Date;
import java.util.List;

/**
 * @author Xuheng Zhou
 * @date 2020/6/8 18:09
 * @desc
 */
@Service
@Transactional
public class IlldiscussServiceImpl implements IlldiscussService {

    @Autowired
    private IlldiscussMapper mapper;

    @Autowired
    private illdiscussDoctorMapper illdiscussDoctorMapper;

    @Autowired
    private DiscussSingupMapper discussSingupMapper;


    /**
     * 查询所有的病历探讨的所有信息
     * @param selectIllDiscussBean
     * @return
     */
    @Override
    public List<IllDiscussParams> selectIllDiscuss(selectIllDiscussBean selectIllDiscussBean) {

        Integer page=selectIllDiscussBean.getPage();
        Integer size=selectIllDiscussBean.getSize();
        page=(page-1)*size;
        selectIllDiscussBean.setPage(page);
        List<IllDiscussParams> list= mapper.selectIllDiscuss(selectIllDiscussBean);
        if(list.size()>0){
            for(IllDiscussParams sid :list){
                Integer discussSignUpCount=selectDiscussSignUpCount(sid.getIlldiscussId());
                Integer disscussGuestCount=selectDisscussGuestCount(sid.getIlldiscussId());
                sid.setPeoplenumber(discussSignUpCount+disscussGuestCount);
            }
            return list;
        }

        return null;
    }

    /**
     * 查询所有的病历探讨信息的数据总条数
     * @param selectIllDiscussBean
     * @return
     */

    @Override
    public Integer selectIllDiscussCount(selectIllDiscussBean selectIllDiscussBean) {
        Integer page= selectIllDiscussBean.getPage();
        System.out.println("--"+page);
        //因为controller中先查询的所有数据，业务处理的时候，page已经减1改变了值，这里的page直接传入mapper进行查询
        Integer count= mapper.selectIllDiscussCount(selectIllDiscussBean);

        return count;
    }

    /**
     * 查询该病历的详情信息
     * @param illdiscussId
     * @return
     */
    @Override
    public IllDiscussInfo selectOneIllDiscussById(Integer illdiscussId) {

        IllDiscussInfo illDiscussInfo=mapper.selectOneIllDiscussById(illdiscussId);
        if (illDiscussInfo!=null) {
            /*
            List<Doctor> list=illDiscussInfo.getGuest();
            //因为参会医生也包括报名参会的医生
            //所以，还要加进报名参加的医生
            List<Doctor> signUplist=discussSingupMapper.selectSignUpJoinDoctor(illdiscussId);

            for (Doctor d : signUplist) {
                list.add(d);
            }
            illDiscussInfo.setGuest(list);
            */
            return illDiscussInfo;
        }
        return null;
    }

    /**
     * 后台管理人员添加病历探讨信息
     * @param illDiscussBean
     * @return
     */
    @Override
    public boolean addIllDiscuss(IllDiscussBean illDiscussBean) {

        //判断添加病历探讨和医生的关系数据是否成功
        boolean tf1=false;
        //添加病历探讨的信息
        boolean tf=mapper.addIllDiscuss(illDiscussBean)>0?true:false;
        //病历探讨添加成功，则添加相应的医生和病历探讨的信息
        if (tf==true) {
            //获取新增的病历探讨的id
            Integer illdiscussId = illDiscussBean.getIlldiscussId();
            //因为参会医生有多个，需要另外对病历探讨与医生的关系进行添加数据
            //解析前台传入的参会医生的id
            for (Integer doctorid : illDiscussBean.getGuestId()) {

                tf1=illdiscussDoctorMapper.insertDiscuss(illdiscussId,doctorid)>0?true:false;
                if (tf1==true){
                    continue;
                }else {
                    return false;
                }

            }
            return true;
        }
        return false;
    }

    /**
     * 查询改该医生发起的所有的病历探讨信息
     * @param doctorId
     * @param page
     * @param size
     * @return
     */

    @Override
    public List<selectIllDiscussByDoctorIdBean> selectIllDiscussByDoctorId(Integer doctorId, Integer page, Integer size) {
        List<selectIllDiscussByDoctorIdBean> list=mapper.selectIllDiscussByDoctorId(doctorId,(page-1)*size,size);
        if (list.size()>0){
            for(selectIllDiscussByDoctorIdBean sid :list){
                Integer discussSignUpCount=selectDiscussSignUpCount(sid.getIlldiscussId());
                Integer disscussGuestCount=selectDisscussGuestCount(sid.getIlldiscussId());
                sid.setPeoplenumber(discussSignUpCount+disscussGuestCount);
            }
            return list;
        }

        return null;
    }

    /**
     * 查询该病历探讨的参会医生（嘉宾）人数
     * @param illdiscussId
     * @return
     */
    private Integer selectDisscussGuestCount(Integer illdiscussId) {
        return illdiscussDoctorMapper.selectDisscussGuestCount(illdiscussId);
    }

    /**
     * 查询该病历探讨的报名且参加的医生人数
     * @param illdiscussId
     * @return
     */
    private Integer selectDiscussSignUpCount(Integer illdiscussId) {
        return discussSingupMapper.selectDiscussSignUpCount(illdiscussId);
    }

    /**
     * 查询该医生发起的病历探讨的数据条数
     * @param doctorId
     * @return
     */
    @Override
    public Integer selectIllDiscussCountByDoctorId(Integer doctorId) {
        return mapper.selectIllDiscussCountByDoctorId(doctorId);
    }

    /**
     * 后台取消病历探讨信息
     * @param illdiscussId
     * @param illdiscussCancelReason
     * @return
     */
    @Override
    public boolean cancelIllDiscuss(Integer illdiscussId, String illdiscussCancelReason) {
        return mapper.cancelIllDiscuss(illdiscussId,illdiscussCancelReason,new Date())>0?true:false;
    }

    /**
     * 修改病历探讨信息
     * @param updateIllDiscussInfo
     * @return
     */
    @Override
    public boolean updateIllDiscuss(updateIllDiscussInfo updateIllDiscussInfo) {
        //判断删除病历探讨和医生的关系数据是否成功
        boolean tf1=false;
        //判断删除之后是否重建成功
        boolean tf2=false;
        //修改病历探讨的信息
        boolean tf=mapper.updateIllDiscuss(updateIllDiscussInfo)>0?true:false;
        //病历探讨修改成功，则修改相应的医生和病历探讨的信息
        if (tf==true) {
            //获取需要修改的病历探讨id
            Integer illdiscussId = updateIllDiscussInfo.getIlldiscussId();
            //获取病历探讨医生关系表的id用于修改参会医生
            List<Integer> list=illdiscussDoctorMapper.selectDisscussDoctorId(illdiscussId);
            //如果updateIllDiscussInfo.getGuestId()不为空，说明想要修改病历探讨的参会医生
            //所以就对医生和病历探讨关系表进行修改

            if((updateIllDiscussInfo.getGuestId())!=null ) {

                tf1=illdiscussDoctorMapper.deleteBylistid(list)>0?true:false;
                //说明原关系表里的数据已经删除成功，接下来就是重新添加
                if (tf1) {

                    for (Integer doctorid : updateIllDiscussInfo.getGuestId()) {

                        tf2 = illdiscussDoctorMapper.insertDiscuss(illdiscussId, doctorid) > 0 ? true : false;
                        //如果重建成功，则continue
                        if (tf2 == true) {
                            continue;
                        } else {
                            return false;
                        }


                    }
                    return true;
                }
                return false;

            }
            return true;
        }
        return false;
    }

    /**
     * 查询该探讨病历的报名医生信息
     * @param illdiscussId
     * @param page
     * @param size
     * @return
     */
    @Override
    public List<DiscussSingupParams> selectDiscSingup(Integer illdiscussId, Integer page, Integer size) {
        return discussSingupMapper.selectDiscSingup(illdiscussId,(page-1)*size,size);
    }

    /**
     * 查询该探讨病历的报名医生信息数据条数
     * @param illdiscussId
     * @return
     */
    @Override
    public Integer selectDiscSingupCount(Integer illdiscussId) {
        return discussSingupMapper.selectDiscSingupCount(illdiscussId);
    }

    @Override
    public boolean deleteIllDiscussById(Integer illdiscussId) {
        return mapper.deleteByPrimaryKey(illdiscussId)>0?true:false;
    }
}
